package J5940;

import java.util.Arrays;

/**
 * 从数组中移除最大值和最小值
 */
public class Test {
    public static void main(String[] args) {
        System.out.println(new Solution().minimumDeletions(new int[]{-14, 61, 29, -18, 59, 13, -67, -16, 55, -57, 7, 74}));
        System.out.println(new Solution().minimumDeletions(new int[]{2, 10, 7, 5, 4, 1, 8, 6}));
//        System.out.println(new Solution().minimumDeletions(new int[]{101}));
    }
}

/**
 * 数学方法
 */
class Solution {
    public int minimumDeletions(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        int[] ints = Arrays.copyOf(nums, nums.length);
        Arrays.sort(ints);
        int min = ints[0];
        int max = ints[ints.length - 1];
        int min_pos = 0;
        int max_pos = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == min) {
                min_pos = i;
            }
            if (nums[i] == max) {
                max_pos = i;
            }
        }

        System.out.println("min --> " + min);
        System.out.println("max --> " + max);
        System.out.println("min_pos --> " + min_pos);
        System.out.println("max_pos --> " + max_pos);
        System.out.println("nums.length --> " + nums.length);
        System.out.println("nums.length/2 --> " + nums.length / 2);

        // 最大值的左右边距
        int max_left = min_pos + 1;
        int max_right = nums.length - min_pos;

        // 最小值的左右边距
        int min_left = max_pos + 1;
        int min_right = nums.length - max_pos;

        // 最小值和最大值独立删除（这里虽然会计算相同方向删除和不同方向删除两种情况，但我们只关心不同方向删除，因为后续的合并删除一定是同一个方向的）
        int sep = Math.min(min_left, min_right) + Math.min(max_left, max_right);
        // 最小值和最大值合并删除（同一个方向）
        int combine = Math.min(Math.max(min_left, max_left), Math.max(min_right, max_right));
        // 独立删除和合并删除，两种情况取更小的
        return Math.min(sep, combine);

//        if (max_pos <= nums.length / 2 && min_pos <= nums.length / 2) {
//            return Math.max(max_pos, min_pos) + 1;
//        }
//        if (max_pos >= nums.length / 2 && min_pos >= nums.length / 2) {
//            return nums.length - min_pos;
//        }
//        if (max_pos <= nums.length / 2 && min_pos >= nums.length / 2) {
//            return max_pos + 1 + nums.length - min_pos;
//        }
//        if (min_pos <= nums.length / 2 && max_pos >= nums.length / 2) {
//            return min_pos + 1 + nums.length - max_pos;
//        }
//        return 0;

    }
}

/**
 * 评论区题解
 */
class Solution2 {
    public int minimumDeletions(int[] nums) {

        // 找到最小值和最大值的位置
        int index_MAX = 0;
        int index_MIN = 0;
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < nums.length; ++i) {
            if (nums[i] > max) {
                max = nums[i];
                index_MAX = i;
            }
            if (nums[i] < min) {
                min = nums[i];
                index_MIN = i;
            }
        }

        // 最大值的左右边距
        int max_left = index_MAX + 1;
        int max_right = nums.length - index_MAX;

        // 最小值的左右边距
        int min_left = index_MIN + 1;
        int min_right = nums.length - index_MIN;

        // 最小值和最大值独立删除（这里虽然会计算相同方向删除和不同方向删除两种情况，但我们只关心不同方向删除，因为后续的合并删除一定是同一个方向的）
        int sep = Math.min(min_left, min_right) + Math.min(max_left, max_right);
        // 最小值和最大值合并删除（同一个方向）
        int combine = Math.min(Math.max(min_left, max_left), Math.max(min_right, max_right));
        // 独立删除和合并删除，两种情况取更小的
        return Math.min(sep, combine);
    }
}
